{
 "cells": [
  {
   "cell_type": "code",
   "id": "initial_id",
   "metadata": {
    "collapsed": true,
    "ExecuteTime": {
     "end_time": "2025-02-09T07:46:42.068614Z",
     "start_time": "2025-02-09T07:46:39.368566Z"
    }
   },
   "source": [
    "# 导入库\n",
    "import matplotlib as mpl\n",
    "# Matplotlib 绘制的图形会直接嵌入到 Notebook 的输出单元格中，而不是弹出一个独立的窗口\n",
    "%matplotlib inline\n",
    "\n",
    "import matplotlib.pyplot as plt\n",
    "import numpy as np\n",
    "import sklearn\n",
    "import pandas as pd\n",
    "\n",
    "# os库提供了一种使用操作系统相关功能的便捷方式，允许与操作系统进行交互\n",
    "import os\n",
    "\n",
    "# sys库主要用于处理Python运行时的环境相关信息以及与解释器的交互\n",
    "import sys\n",
    "import time\n",
    "\n",
    "# tqdm库是一个快速，可扩展的Python进度条，可以在 Python 长循环中添加一个进度提示信息，用户只需要封装任意的迭代器 tqdm(iterator)，即可获得一个进度条显示迭代进度。\n",
    "from tqdm.auto import tqdm\n",
    "import torch\n",
    "\n",
    "# torch.nn是PyTorch中用于构建神经网络的模块\n",
    "import torch.nn as nn\n",
    "\n",
    "# torch.nn.functional是PyTorch中包含了神经网络的一些常用函数\n",
    "import torch.nn.functional as F\n",
    "\n",
    "# Python 中的一个属性，用于获取当前 Python 解释器的版本信息。它返回一个命名元组（named tuple）\n",
    "print(sys.version_info)\n",
    "\n",
    "# 遍历模块，打印模块名称和版本信息，快速检查当前环境中安装的某些常用 Python 库的版本信息\n",
    "for module in mpl, np, pd, sklearn, torch:\n",
    "    print(module.__name__, module.__version__)\n",
    "\n",
    "# 判断是否有 GPU，如果有，则使用 GPU 进行训练，否则使用 CPU 进行训练\n",
    "# torch.cuda.is_available()用于判断是否有GPU\n",
    "# torch.device(\"cuda:0\")创建一个 PyTorch 设备对象，表示使用第一个 GPU（索引为 0）\n",
    "# torch.device(\"cpu\")创建一个 PyTorch 设备对象，表示使用 CPU\n",
    "device = torch.device(\"cuda:0\") if torch.cuda.is_available() else torch.device(\"cpu\")\n",
    "print(device)\n",
    "\n",
    "seed = 42\n"
   ],
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "sys.version_info(major=3, minor=12, micro=3, releaselevel='final', serial=0)\n",
      "matplotlib 3.10.0\n",
      "numpy 1.26.4\n",
      "pandas 2.2.3\n",
      "sklearn 1.6.0\n",
      "torch 2.3.1+cu121\n",
      "cuda:0\n"
     ]
    }
   ],
   "execution_count": 1
  },
  {
   "metadata": {},
   "cell_type": "markdown",
   "source": "# 数据准备",
   "id": "6ec5d583c74a7e68"
  },
  {
   "metadata": {
    "ExecuteTime": {
     "end_time": "2025-02-09T07:46:49.499491Z",
     "start_time": "2025-02-09T07:46:48.538567Z"
    }
   },
   "cell_type": "code",
   "source": [
    "# 提供了许多常用的公开数据集\n",
    "from torchvision import datasets\n",
    "\n",
    "# 导入 ToTensor 类，它是一个图像变换工具，用于将 PIL 图像或 NumPy 数组转换为 PyTorch 张量（torch.Tensor）\n",
    "# 同时将像素值从 [0, 255] 缩放到 [0.0, 1.0]\n",
    "# 在加载数据集时，通常需要将图像转换为张量，以便输入到神经网络中\n",
    "from torchvision.transforms import ToTensor\n",
    "\n",
    "# 图像预处理工具，用于对图像进行各种变换（如缩放、裁剪、旋转、归一化等）\n",
    "from torchvision import transforms\n",
    "from torch.utils.data import random_split\n",
    "\n",
    "# PyTorch 中用于定义图像预处理流水线的方式\n",
    "# transforms.Compose 将多个图像变换操作组合在一起，按顺序依次应用到图像上\n",
    "# 传入一个空列表 []，则表示不进行任何变换,定义一个空的变换流水线\n",
    "transform = transforms.Compose([ToTensor()])\n",
    "\n",
    "# 训练集\n",
    "train_ds = datasets.FashionMNIST(\n",
    "    root=\"data\",  # 数据集存储路径\n",
    "    train=True,  # 加载训练集\n",
    "    download=True,  # 如果数据集不存在，则自动下载\n",
    "    transform=transform  # 对图像应用的变换\n",
    ")\n",
    "\n",
    "# 测试集\n",
    "test_ds = datasets.FashionMNIST(\n",
    "    root=\"data\",  # 数据集存储路径\n",
    "    train=True,  # 加载测试集\n",
    "    download=True,  # 如果数据集不存在，则自动下载\n",
    "    transform=transform  # 对图像应用的变换\n",
    ")\n",
    "\n",
    "# torchvision 数据集里没有提供训练集和验证集的划分\n",
    "# 这里用 random_split 按照 11 : 1 的比例来划分数据集\n",
    "# torch.Generator().manual_seed(seed) 设置随机种子，保证划分结果一致\n",
    "train_ds, val_ds = random_split(train_ds, [55000, 5000], torch.Generator().manual_seed(seed))"
   ],
   "id": "ff0e6bad0a06b3ad",
   "outputs": [],
   "execution_count": 2
  },
  {
   "metadata": {
    "ExecuteTime": {
     "end_time": "2025-02-09T07:46:57.062219Z",
     "start_time": "2025-02-09T07:46:53.744945Z"
    }
   },
   "cell_type": "code",
   "source": [
    "# 计算数据集中所有图像的均值和标准差\n",
    "# ds：数据集对象，通常是一个可迭代对象，返回元组 (img, label)\n",
    "def cal_mean_std(ds):\n",
    "    # 初始化均值和标准差的累加器\n",
    "    mean = 0.\n",
    "    std = 0.\n",
    "\n",
    "    # 对每个图像的每个通道计算均值，然后对所有图像求平均\n",
    "\n",
    "    # 遍历每张图片,_ 是标签（未使用）\n",
    "    for img, _ in ds:\n",
    "        # 计算每张图片的均值和方差,dim=(1, 2) 表示在高度和宽度维度上计算均值。\n",
    "        mean += img.mean(dim=(1, 2))\n",
    "        std += img.std(dim=(1, 2))\n",
    "\n",
    "    # 将累加的均值和标准差除以数据集大小，得到整个数据集的均值和标准差\n",
    "    mean /= len(ds)\n",
    "    std /= len(ds)\n",
    "    return mean, std\n",
    "\n",
    "\n",
    "print(cal_mean_std(train_ds))"
   ],
   "id": "dd5925805c2eb533",
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "(tensor([0.2856]), tensor([0.3202]))\n"
     ]
    }
   ],
   "execution_count": 3
  },
  {
   "metadata": {
    "ExecuteTime": {
     "end_time": "2025-02-09T07:46:59.576661Z",
     "start_time": "2025-02-09T07:46:59.572488Z"
    }
   },
   "cell_type": "code",
   "source": [
    "img, label = train_ds[0]\n",
    "img.shape, label"
   ],
   "id": "bfac4960e752dfa7",
   "outputs": [
    {
     "data": {
      "text/plain": [
       "(torch.Size([1, 28, 28]), 9)"
      ]
     },
     "execution_count": 4,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "execution_count": 4
  },
  {
   "metadata": {
    "ExecuteTime": {
     "end_time": "2025-02-09T07:47:03.406896Z",
     "start_time": "2025-02-09T07:47:03.403772Z"
    }
   },
   "cell_type": "code",
   "source": [
    "from torch.utils.data.dataloader import DataLoader\n",
    "\n",
    "batch_size = 32\n",
    "# 从数据集到dataloader\n",
    "train_loader = DataLoader(train_ds, batch_size=batch_size, shuffle=True, num_workers=4)\n",
    "val_loader = DataLoader(val_ds, batch_size=batch_size, shuffle=False, num_workers=4)\n",
    "test_loader = DataLoader(test_ds, batch_size=batch_size, shuffle=False, num_workers=4)"
   ],
   "id": "9bb7d6c6c33a92f5",
   "outputs": [],
   "execution_count": 5
  },
  {
   "metadata": {},
   "cell_type": "markdown",
   "source": [
    "# 模型定义\n",
    "使用深度可分离的卷积\n",
    "\n",
    "pytorch需要自行实现"
   ],
   "id": "8fd7e47a60965b5"
  },
  {
   "metadata": {},
   "cell_type": "markdown",
   "source": [
    "### 深度可分离卷积分为两步：\n",
    "\n",
    "深度卷积（Depthwise Convolution）:\n",
    "\n",
    "对每个输入通道单独进行卷积操作。\n",
    "\n",
    "输入通道数为 C_in，输出通道数也为 C_in。\n",
    "\n",
    "提取每个通道的空间特征。\n",
    "\n",
    "逐点卷积（Pointwise Convolution）:\n",
    "\n",
    "使用 1x1 卷积核，将深度卷积的输出通道数从 C_in 映射到 C_out。\n",
    "\n",
    "融合通道特征，生成最终的输出。\n",
    "\n",
    "### 深度可分离卷积的优点\n",
    "计算量更少:\n",
    "\n",
    "深度卷积和逐点卷积的计算量远小于标准卷积。\n",
    "\n",
    "参数量更少:\n",
    "\n",
    "深度卷积和逐点卷积的参数量远小于标准卷积。\n",
    "\n",
    "适合轻量级模型:\n",
    "\n",
    "广泛应用于移动端和嵌入式设备上的轻量级神经网络（如 MobileNet）。"
   ],
   "id": "5fd5bb7b1a2f48c7"
  },
  {
   "metadata": {
    "ExecuteTime": {
     "end_time": "2025-02-09T08:09:03.796410Z",
     "start_time": "2025-02-09T08:09:03.792170Z"
    }
   },
   "cell_type": "code",
   "source": [
    "# 定义一个名为 DepthWiseConv2d 的类，继承自 nn.Module\n",
    "class DepthWiseConv2d(nn.Module):\n",
    "\n",
    "    # in_channels: 输入通道数。\n",
    "    # out_channels: 输出通道数。\n",
    "    # kernel_size: 卷积核大小。\n",
    "    # stride: 卷积步幅，默认值为 1。\n",
    "    # padding: 填充大小，默认值为 0。\n",
    "    # bias: 是否使用偏置，默认值为 True。\n",
    "    # 初始化深度可分离卷积的层结构\n",
    "    def __init__(self, in_channels, out_channels, kernel_size, stride=1, padding=0, bias=True):\n",
    "        # 调用父类的初始化函数\n",
    "        super(DepthWiseConv2d, self).__init__()\n",
    "\n",
    "        # 定义深度卷积（Depthwise Convolution）层\n",
    "        # in_channels: 输入通道数。\n",
    "        # in_channels: 输出通道数（与输入通道数相同）。\n",
    "        # kernel_size: 卷积核大小。\n",
    "        # stride: 卷积步幅。\n",
    "        # padding: 填充大小。\n",
    "        # groups=in_channels: 将输入通道分组，每组一个通道，实现深度卷积。\n",
    "        # bias=False: 深度卷积层不使用偏置。\n",
    "        # 深度卷积对每个输入通道单独进行卷积操作，输出通道数与输入通道数相同\n",
    "        # 减少计算量，提取每个通道的空间特征。\n",
    "        self.depthwise_conv = nn.Conv2d(in_channels, in_channels, kernel_size, stride, padding, groups=in_channels,\n",
    "                                        bias=False)\n",
    "\n",
    "        # 定义逐点卷积（Pointwise Convolution）层\n",
    "        # 逐点卷积使用 1x1 卷积核，将深度卷积的输出通道数映射到目标输出通道数。\n",
    "        # 结合深度卷积和逐点卷积，实现高效的通道特征融合。\n",
    "        self.pointwise_conv = nn.Conv2d(in_channels, out_channels, 1, 1, 0, bias=bias)\n",
    "\n",
    "    def forward(self, x):\n",
    "        # self.depthwise_conv(x): 对输入数据进行深度卷积，提取每个通道的空间特征\n",
    "        x = self.depthwise_conv(x)\n",
    "\n",
    "        # self.pointwise_conv(x): 对深度卷积的输出进行逐点卷积，融合通道特征。\n",
    "        x = self.pointwise_conv(x)\n",
    "        return x"
   ],
   "id": "37a47ee84fb32e8f",
   "outputs": [],
   "execution_count": 7
  },
  {
   "metadata": {
    "ExecuteTime": {
     "end_time": "2025-02-09T08:14:42.007121Z",
     "start_time": "2025-02-09T08:14:41.998720Z"
    }
   },
   "cell_type": "code",
   "source": [
    "class DepthWiseCNN(nn.Module):\n",
    "    def __init__(self, activation=\"relu\"):\n",
    "        super(DepthWiseCNN, self).__init__()\n",
    "        self.activation = F.relu if activation == \"relu\" else F.selu\n",
    "        self.conv1 = nn.Conv2d(in_channels=1, out_channels=32, kernel_size=3, padding=\"same\")\n",
    "        self.conv2 = DepthWiseConv2d(in_channels=32, out_channels=32, kernel_size=3, padding=\"same\")\n",
    "        self.pool = nn.MaxPool2d(2, 2)\n",
    "        self.conv3 = DepthWiseConv2d(in_channels=32, out_channels=64, kernel_size=3, padding=\"same\")\n",
    "        self.conv4 = DepthWiseConv2d(in_channels=64, out_channels=64, kernel_size=3, padding=\"same\")\n",
    "        self.pool = nn.MaxPool2d(2, 2)\n",
    "        self.conv5 = DepthWiseConv2d(in_channels=64, out_channels=128, kernel_size=3, padding=\"same\")\n",
    "        self.conv6 = DepthWiseConv2d(in_channels=128, out_channels=128, kernel_size=3, padding=\"same\")\n",
    "        self.pool = nn.MaxPool2d(2, 2)\n",
    "        self.flatten = nn.Flatten()\n",
    "        self.fc1 = nn.Linear(128 * 3 * 3, 128)\n",
    "        self.fc2 = nn.Linear(128, 10)\n",
    "\n",
    "        self.init_weights()\n",
    "\n",
    "    def init_weights(self):\n",
    "        for m in self.modules():\n",
    "            if isinstance(m, (nn.Linear, nn.Conv2d)):\n",
    "                nn.init.xavier_uniform_(m.weight)\n",
    "                if m.bias is not None:\n",
    "                    nn.init.zeros_(m.bias)\n",
    "\n",
    "    def forward(self, x):\n",
    "        act = self.activation\n",
    "        x = self.pool(act(self.conv2(act(self.conv1(x)))))\n",
    "        x = self.pool(act(self.conv4(act(self.conv3(x)))))\n",
    "        x = self.pool(act(self.conv6(act(self.conv5(x)))))\n",
    "        x = self.flatten(x)\n",
    "        x = act(self.fc1(x))\n",
    "        x = self.fc2(x)\n",
    "        return x\n",
    "\n",
    "\n",
    "for idx, (key, value) in enumerate(DepthWiseCNN().named_parameters()):\n",
    "    print(f\"{key}\\tparamerters num: {np.prod(value.shape)}\")"
   ],
   "id": "2f8cff883ab4bf45",
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "conv1.weight\tparamerters num: 288\n",
      "conv1.bias\tparamerters num: 32\n",
      "conv2.depthwise_conv.weight\tparamerters num: 288\n",
      "conv2.pointwise_conv.weight\tparamerters num: 1024\n",
      "conv2.pointwise_conv.bias\tparamerters num: 32\n",
      "conv3.depthwise_conv.weight\tparamerters num: 288\n",
      "conv3.pointwise_conv.weight\tparamerters num: 2048\n",
      "conv3.pointwise_conv.bias\tparamerters num: 64\n",
      "conv4.depthwise_conv.weight\tparamerters num: 576\n",
      "conv4.pointwise_conv.weight\tparamerters num: 4096\n",
      "conv4.pointwise_conv.bias\tparamerters num: 64\n",
      "conv5.depthwise_conv.weight\tparamerters num: 576\n",
      "conv5.pointwise_conv.weight\tparamerters num: 8192\n",
      "conv5.pointwise_conv.bias\tparamerters num: 128\n",
      "conv6.depthwise_conv.weight\tparamerters num: 1152\n",
      "conv6.pointwise_conv.weight\tparamerters num: 16384\n",
      "conv6.pointwise_conv.bias\tparamerters num: 128\n",
      "fc1.weight\tparamerters num: 147456\n",
      "fc1.bias\tparamerters num: 128\n",
      "fc2.weight\tparamerters num: 1280\n",
      "fc2.bias\tparamerters num: 10\n"
     ]
    }
   ],
   "execution_count": 9
  },
  {
   "metadata": {
    "ExecuteTime": {
     "end_time": "2025-02-09T08:15:10.163336Z",
     "start_time": "2025-02-09T08:15:10.158132Z"
    }
   },
   "cell_type": "code",
   "source": [
    "def count_parameters(model):  #计算模型总参数量\n",
    "    return sum(p.numel() for p in model.parameters() if p.requires_grad)\n",
    "\n",
    "\n",
    "count_parameters(DepthWiseCNN())"
   ],
   "id": "2721d9ba4aa8da4f",
   "outputs": [
    {
     "data": {
      "text/plain": [
       "184234"
      ]
     },
     "execution_count": 11,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "execution_count": 11
  },
  {
   "metadata": {},
   "cell_type": "markdown",
   "source": "# 模型训练",
   "id": "3046462752562109"
  },
  {
   "metadata": {
    "ExecuteTime": {
     "end_time": "2025-02-09T08:15:31.416358Z",
     "start_time": "2025-02-09T08:15:28.788212Z"
    }
   },
   "cell_type": "code",
   "source": [
    "from torch.utils.tensorboard import SummaryWriter\n",
    "\n",
    "\n",
    "class TensorBoardCallback:\n",
    "    def __init__(self, log_dir, flush_secs=10):\n",
    "        \"\"\"\n",
    "        Args:\n",
    "            log_dir (str): dir to write log.\n",
    "            flush_secs (int, optional): write to dsk each flush_secs seconds. Defaults to 10.\n",
    "        \"\"\"\n",
    "        self.writer = SummaryWriter(log_dir=log_dir,\n",
    "                                    flush_secs=flush_secs)  # 实例化SummaryWriter, log_dir是log存放路径，flush_secs是每隔多少秒写入磁盘\n",
    "\n",
    "    def draw_model(self, model, input_shape):  #graphs\n",
    "        self.writer.add_graph(model, input_to_model=torch.randn(input_shape))  # 画模型图\n",
    "\n",
    "    def add_loss_scalars(self, step, loss, val_loss):\n",
    "        self.writer.add_scalars(\n",
    "            main_tag=\"training/loss\",\n",
    "            tag_scalar_dict={\"loss\": loss, \"val_loss\": val_loss},\n",
    "            global_step=step,\n",
    "        )  # 画loss曲线, main_tag是主tag，tag_scalar_dict是子tag，global_step是步数\n",
    "\n",
    "    def add_acc_scalars(self, step, acc, val_acc):\n",
    "        self.writer.add_scalars(\n",
    "            main_tag=\"training/accuracy\",\n",
    "            tag_scalar_dict={\"accuracy\": acc, \"val_accuracy\": val_acc},\n",
    "            global_step=step,\n",
    "        )  # 画acc曲线, main_tag是主tag，tag_scalar_dict是子tag，global_step是步数\n",
    "\n",
    "    def add_lr_scalars(self, step, learning_rate):\n",
    "        self.writer.add_scalars(\n",
    "            main_tag=\"training/learning_rate\",\n",
    "            tag_scalar_dict={\"learning_rate\": learning_rate},\n",
    "            global_step=step,\n",
    "        )  # 画lr曲线, main_tag是主tag，tag_scalar_dict是子tag，global_step是步数\n",
    "\n",
    "    def __call__(self, step, **kwargs):\n",
    "        # add loss,把loss，val_loss取掉，画loss曲线\n",
    "        loss = kwargs.pop(\"loss\", None)\n",
    "        val_loss = kwargs.pop(\"val_loss\", None)\n",
    "        if loss is not None and val_loss is not None:\n",
    "            self.add_loss_scalars(step, loss, val_loss)  # 画loss曲线\n",
    "        # add acc\n",
    "        acc = kwargs.pop(\"acc\", None)\n",
    "        val_acc = kwargs.pop(\"val_acc\", None)\n",
    "        if acc is not None and val_acc is not None:\n",
    "            self.add_acc_scalars(step, acc, val_acc)  # 画acc曲线\n",
    "        # add lr\n",
    "        learning_rate = kwargs.pop(\"lr\", None)\n",
    "        if learning_rate is not None:\n",
    "            self.add_lr_scalars(step, learning_rate)  # 画lr曲线\n"
   ],
   "id": "a431cc494bc143a7",
   "outputs": [],
   "execution_count": 12
  },
  {
   "metadata": {
    "ExecuteTime": {
     "end_time": "2025-02-09T08:15:32.726117Z",
     "start_time": "2025-02-09T08:15:32.720982Z"
    }
   },
   "cell_type": "code",
   "source": [
    "# 定义一个名为 SaveCheckpointsCallback 的类。\n",
    "# 该类用于在训练过程中保存模型的检查点。封装保存检查点的逻辑，方便在训练过程中调用\n",
    "class SaveCheckpointsCallback:\n",
    "    \"\"\"\n",
    "    Callback to save model checkpoints during training.\n",
    "    \"\"\"\n",
    "\n",
    "    #定义类的构造函数，接受以下参数：\n",
    "    # save_dir: 检查点保存的目录。\n",
    "    # save_step: 每隔多少步保存一次检查点，默认值为 500。\n",
    "    # save_best_only: 是否只保存性能最好的检查点，默认值为 True\n",
    "    # 原理：初始化回调类的参数和状态\n",
    "    def __init__(self, save_dir, save_step=500, save_best_only=True):\n",
    "\n",
    "        # 将传入的参数保存为类的属性\n",
    "        self.save_dir = save_dir\n",
    "        self.save_step = save_step\n",
    "        self.save_best_only = save_best_only\n",
    "\n",
    "        # 初始化一个变量 best_metrics，用于记录当前最好的性能指标值，初始值为 -1\n",
    "        # 原理: 用于比较当前模型的性能是否优于之前保存的模型,当 save_best_only 为 True 时，只保存性能最好的模型\n",
    "        self.best_metrics = -1\n",
    "\n",
    "        # 检查保存目录是否存在，如果不存在则创建该目录\n",
    "        # os.path.exists()用于判断路径是否存在, os.mkdir()用于创建目录\n",
    "        if not os.path.exists(self.save_dir):\n",
    "            os.mkdir(self.save_dir)\n",
    "\n",
    "    # 定义 __call__ 方法，使类的实例可以像函数一样调用。参数包括：\n",
    "    # step: 当前训练的步数。\n",
    "    # state_dict: 模型的状态字典（包含模型参数）。\n",
    "    # metric: 当前模型的性能指标值（如验证集准确率），默认为 None\n",
    "    # 在训练过程中定期调用该方法，保存检查点\n",
    "    def __call__(self, step, state_dict, metric=None):\n",
    "\n",
    "        # 检查当前步数是否是 save_step 的倍数，如果不是则直接返回\n",
    "        # 控制保存检查点的频率，避免频繁保存\n",
    "        if step % self.save_step > 0:\n",
    "            return\n",
    "\n",
    "        # 检查是否只保存性能最好的检查点\n",
    "        # 根据 save_best_only 的值决定保存策略,提供两种保存策略：定期保存和只保存最佳模型\n",
    "        if self.save_best_only:\n",
    "\n",
    "            # 如果 save_best_only 为 True，则要求 metric 不能为 None。\n",
    "            # 原理: 使用 assert 断言确保 metric 有值。如果 metric 为 None，无法判断模型性能是否更好，因此需要提前检查\n",
    "            assert metric is not None\n",
    "\n",
    "            # 检查当前模型的性能指标是否优于之前保存的最佳模型\n",
    "            # 只保存性能更好的模型，避免保存性能下降的模型\n",
    "            if metric >= self.best_metrics:\n",
    "                # 将模型的状态字典保存到指定目录下的 best.ckpt 文件中\n",
    "                # 使用 torch.save 保存模型参数。保存当前性能最好的模型，方便后续加载和使用\n",
    "                torch.save(state_dict, os.path.join(self.save_dir, \"best.ckpt\"))\n",
    "\n",
    "                # 更新 best_metrics 为当前模型的性能指标值\n",
    "                self.best_metrics = metric\n",
    "\n",
    "        # 如果 save_best_only 为 False，则执行以下逻辑\n",
    "        # 定期保存检查点，不关心模型性能是否更好\n",
    "        else:\n",
    "\n",
    "            # 将模型的状态字典保存到指定目录下，文件名为当前步数\n",
    "            torch.save(state_dict, os.path.join(self.save_dir, f\"{step}.ckpt\"))"
   ],
   "id": "c129eedb9186141a",
   "outputs": [],
   "execution_count": 13
  },
  {
   "metadata": {
    "ExecuteTime": {
     "end_time": "2025-02-09T08:15:36.671423Z",
     "start_time": "2025-02-09T08:15:36.667425Z"
    }
   },
   "cell_type": "code",
   "source": [
    "# 定义一个名为 EarlyStopCallback 的类.用于监控模型在验证集上的性能，并在性能不再提升时触发早停。\n",
    "# 封装早停的逻辑，方便在训练过程中调用\n",
    "class EarlyStopCallback:\n",
    "\n",
    "    # 定义类的构造函数，接受以下参数\n",
    "    # patience: 容忍的轮次数，默认值为 5。如果在 patience 轮内性能没有提升，则触发早停。\n",
    "    # min_delta: 性能提升的最小阈值，默认值为 0.01。只有当性能提升超过该阈值时，才认为模型有改进。\n",
    "    # 初始化早停回调的参数和状态\n",
    "    def __init__(self, patience=5, min_delta=0.01):\n",
    "\n",
    "        # 将传入的参数保存为类的属性\n",
    "        self.patience = patience\n",
    "        self.min_delta = min_delta\n",
    "\n",
    "        self.best_metric = -1  # 用于比较当前模型的性能是否优于之前的最佳性能\n",
    "\n",
    "        # 初始化一个计数器 counter，用于记录性能没有提升的连续轮次数，初始值为 0\n",
    "        # 当性能没有提升时，计数器增加；当性能提升时，计数器重置,用于判断是否达到了早停的条件\n",
    "        self.counter = 0\n",
    "\n",
    "    # 训练过程中定期调用该方法，更新早停状态\n",
    "    def __call__(self, metric):\n",
    "\n",
    "        # 检查当前性能指标是否比之前的最佳性能提升了至少 min_delta\n",
    "        # 避免微小的波动触发早停,当性能有显著提升时，才认为模型有改进\n",
    "        if metric >= self.best_metric + self.min_delta:\n",
    "\n",
    "            self.best_metric = metric  # 记录当前最佳性能\n",
    "            self.counter = 0  # 性能有提升时，重置计数器,重新开始计算性能没有提升的连续轮次数\n",
    "\n",
    "        # 性能没有提升时，增加计数器\n",
    "        else:\n",
    "            self.counter += 1  # 记录性能没有提升的连续轮次数\n",
    "\n",
    "    # 定义一个只读属性 early_stop，用于判断是否触发早停。\n",
    "    # 使用 @property 装饰器将方法转换为属性。方便外部代码通过属性访问早停状态。\n",
    "    @property\n",
    "    def early_stop(self):\n",
    "\n",
    "        # 检查计数器 counter 是否大于或等于 patience\n",
    "        # 提供早停的触发条件\n",
    "        return self.counter >= self.patience"
   ],
   "id": "a6035c51236ca12b",
   "outputs": [],
   "execution_count": 14
  },
  {
   "metadata": {
    "ExecuteTime": {
     "end_time": "2025-02-09T08:15:40.850365Z",
     "start_time": "2025-02-09T08:15:40.802528Z"
    }
   },
   "cell_type": "code",
   "source": [
    "from sklearn.metrics import accuracy_score\n",
    "\n",
    "\n",
    "# 这是一个装饰器，用于禁用梯度计算。\n",
    "# 在评估模型时，我们不需要计算梯度，因为不会进行反向传播和参数更新。禁用梯度计算可以减少内存消耗并加速计算。\n",
    "@torch.no_grad()\n",
    "# 定义评估函数，接受三个参数：model（要评估的模型）、dataloader（数据加载器，用于提供评估数据）、loss_fct（损失函数）。\n",
    "# 用于评估模型在给定数据集上的性能。\n",
    "# 通过封装评估过程，可以方便地在不同模型和数据集上重复使用。\n",
    "def evaluating(model, dataloader, loss_fct):\n",
    "    # 初始化三个空列表，分别用于存储每个批次的损失、预测标签和真实标签。\n",
    "    # 用于累积所有批次的损失和标签，以便后续计算平均损失和准确率。\n",
    "    # 累积所有批次的结果可以更准确地反映模型在整个数据集上的性能。\n",
    "    loss_list = []  # 记录损失\n",
    "    pred_list = []  # 记录预测\n",
    "    label_list = []  # 记录标签\n",
    "\n",
    "    # 遍历数据加载器中的每个批次，datas 是输入数据，labels 是对应的真实标签\n",
    "    for datas, labels in dataloader:\n",
    "        # 将输入数据和标签移动到指定的设备（GPU或CPU），转到GPU可以加速计算\n",
    "        datas = datas.to(device)\n",
    "        labels = labels.to(device)\n",
    "\n",
    "        # 将输入数据传递给模型，得到模型的输出 logits（通常是未归一化的预测分数）。\n",
    "        # 模型的前向传播过程，计算输入数据对应的输出。通过模型的输出可以计算损失和预测标签。\n",
    "        logits = model(datas)\n",
    "\n",
    "        # 将当前批次的损失值（转换为 Python 浮点数）添加到 loss_list 中。\n",
    "        # loss.item() 将张量中的单个值提取为 Python 浮点数。\n",
    "        # 累积所有批次的损失值，以便后续计算平均损失。\n",
    "        loss = loss_fct(logits, labels)\n",
    "        loss_list.append(loss.item())\n",
    "\n",
    "        # 通过 argmax 函数获取模型预测的类别标签。axis=-1 表示在最后一个维度上取最大值对应的索引。\n",
    "        # logits 通常是每个类别的分数，argmax 找到分数最高的类别作为预测结果。\n",
    "        # 将模型的输出转换为具体的类别标签，便于与真实标签进行比较。\n",
    "        preds = logits.argmax(axis=-1)\n",
    "\n",
    "        # 将预测标签从 GPU 移动到 CPU，并转换为 NumPy 数组，再转换为 Python 列表，然后添加到 pred_list 中。\n",
    "        # preds.cpu().numpy().tolist() 将张量转换为 Python 列表。\n",
    "        # 累积所有批次的预测标签，以便后续计算准确率。\n",
    "        pred_list.extend(preds.cpu().numpy().tolist())\n",
    "        label_list.extend(labels.cpu().numpy().tolist())\n",
    "\n",
    "    #计算预测标签和真实标签之间的准确率\n",
    "    acc = accuracy_score(label_list, pred_list)\n",
    "\n",
    "    #返回所有批次的平均损失和准确率。\n",
    "    return np.mean(loss_list), acc"
   ],
   "id": "b38dca6fca83e97",
   "outputs": [],
   "execution_count": 15
  },
  {
   "metadata": {
    "ExecuteTime": {
     "end_time": "2025-02-09T08:48:45.676778Z",
     "start_time": "2025-02-09T08:48:45.508837Z"
    }
   },
   "cell_type": "code",
   "source": [
    "# 定义一个名为 training 的函数，用于训练模型。参数包括：\n",
    "# model: 要训练的模型。\n",
    "# train_loader: 训练数据的数据加载器。\n",
    "# val_loader: 验证数据的数据加载器。\n",
    "# epoch: 训练的轮数。\n",
    "# loss_fct: 损失函数。\n",
    "# optimizer: 优化器。\n",
    "# eval_step: 每隔多少步评估一次验证集性能，默认值为 500。\n",
    "# 该函数通过遍历训练数据，更新模型参数，并定期评估验证集性能。封装训练过程，方便重复使用\n",
    "def training(\n",
    "        model,\n",
    "        train_loader,\n",
    "        val_loader,\n",
    "        epoch,\n",
    "        loss_fct,\n",
    "        optimizer,\n",
    "        tensorboard_callback=None,\n",
    "        save_ckpt_callback=None,\n",
    "        early_stop_callback=None,\n",
    "        eval_step=500,\n",
    "):\n",
    "    # 初始化一个字典 record_dict，用于记录训练和验证过程中的损失和准确率。\n",
    "    # 通过记录训练和验证的性能，可以分析模型的训练过程。方便后续绘制训练曲线或分析模型表现。\n",
    "    record_dict = {\n",
    "        \"train\": [],  # \"train\": 存储训练集的损失和准确率。\n",
    "        \"val\": []  # \"val\": 存储验证集的损失和准确率。\n",
    "    }\n",
    "\n",
    "    # 初始化一个全局步数计数器 global_step，用于记录当前训练的步数。\n",
    "    # 步数用于控制何时评估验证集性能。通过步数而不是轮数来控制评估频率，更灵活。\n",
    "    global_step = 0\n",
    "\n",
    "    # 将模型设置为训练模式。在训练模式下，模型会启用一些特定于训练的功能（如 Dropout 和 BatchNorm）。\n",
    "    # 确保模型在训练时行为正确。\n",
    "    model.train()\n",
    "\n",
    "    # 使用 tqdm 创建一个进度条，总长度为 epoch * len(train_loader)，即总训练步数。\n",
    "    # tqdm 是一个进度条库，用于显示训练进度。\n",
    "    # 提供可视化的训练进度，方便监控训练过程。\n",
    "    with tqdm(total=epoch * len(train_loader)) as pbar:\n",
    "\n",
    "        # 外层循环，遍历每个训练轮次。每个轮次会遍历整个训练数据集一次。\n",
    "        # 多轮训练可以提高模型的性能。\n",
    "        for epoch_id in range(epoch):\n",
    "\n",
    "            # 内层循环，遍历训练数据加载器中的每个批次。\n",
    "            for datas, labels in train_loader:\n",
    "\n",
    "                # 将输入数据和标签移动到指定的设备（GPU或CPU），转到GPU可以加速计算\n",
    "                datas = datas.to(device)\n",
    "                labels = labels.to(device)\n",
    "\n",
    "                # 清除优化器中之前的梯度。\n",
    "                # PyTorch 会累积梯度，因此在每次反向传播前需要清除之前的梯度。避免梯度累积导致错误的参数更新。\n",
    "                optimizer.zero_grad()\n",
    "\n",
    "                logits = model(datas)  # 模型前向计算\n",
    "                loss = loss_fct(logits, labels)  # 计算损失\n",
    "\n",
    "                # 计算损失相对于模型参数的梯度。\n",
    "                # 反向传播算法，通过链式法则计算梯度。梯度用于更新模型参数，以最小化损失。\n",
    "                loss.backward()\n",
    "\n",
    "                # 使用优化器更新模型参数。\n",
    "                optimizer.step()\n",
    "\n",
    "                preds = logits.argmax(axis=-1)  # 通过 argmax 函数获取模型预测的类别标签。\n",
    "                acc = accuracy_score(labels.cpu().numpy(), preds.cpu().numpy())  # 计算当前批次的准确率\n",
    "                loss = loss.cpu().item()  # 将损失值从 GPU 移动到 CPU，并转换为 Python 浮点数。方便记录和打印损失值。\n",
    "\n",
    "                # 将当前批次的损失、准确率和步数记录到 record_dict[\"train\"] 中\n",
    "                # 累积训练过程中的性能指标。方便后续分析训练过程\n",
    "                record_dict[\"train\"].append({\n",
    "                    \"loss\": loss, \"acc\": acc, \"step\": global_step\n",
    "                })\n",
    "\n",
    "                # 每隔 eval_step 步评估一次验证集性能。\n",
    "                # 使用 global_step 控制评估频率。定期评估验证集性能，避免过拟合。\n",
    "                if global_step % eval_step == 0:\n",
    "                    # 将模型设置为评估模式\n",
    "                    model.eval()\n",
    "\n",
    "                    # 调用 evaluating 函数计算验证集的损失和准确率\n",
    "                    # 在验证集上评估模型性能。验证集性能反映了模型的泛化能力。\n",
    "                    val_loss, val_acc = evaluating(model, val_loader, loss_fct)\n",
    "\n",
    "                    # 将验证集的损失、准确率和步数记录到 record_dict[\"val\"] 中。\n",
    "                    record_dict[\"val\"].append({\n",
    "                        \"loss\": val_loss, \"acc\": val_acc, \"step\": global_step\n",
    "                    })\n",
    "\n",
    "                    # 将模型设置为训练模式\n",
    "                    model.train()\n",
    "\n",
    "                    # 1. 使用 tensorboard 可视化\n",
    "                    if tensorboard_callback is not None:\n",
    "                        # 调用 tensorboard 回调函数，记录训练过程中的关键指标\n",
    "                        tensorboard_callback(\n",
    "                            global_step,  # 当前训练的全局步数，用于在 TensorBoard 中标识不同的训练阶段\n",
    "                            loss=loss, val_loss=val_loss,  # 记录训练集和验证集的损失值，用于监控模型在训练和验证集上的表现\n",
    "                            acc=acc, val_acc=val_acc,  # 记录训练集和验证集的准确率，用于监控模型的分类性能\n",
    "                            lr=optimizer.param_groups[0][\"lr\"],  # 取出当前学习率，用于监控学习率的变化，确保学习率调整策略正常工作\n",
    "                        )\n",
    "\n",
    "                    # 2. 保存模型权重 save model checkpoint\n",
    "                    if save_ckpt_callback is not None:\n",
    "                        # 调用保存模型权重的回调函数，保存当前模型的权重\n",
    "                        save_ckpt_callback(\n",
    "                            global_step,  # 当前训练的全局步数，用于标识保存的模型权重对应的训练阶段\n",
    "                            model.state_dict(),  # 保存模型的当前状态字典（即模型的所有参数），以便后续可以恢复模型\n",
    "                            metric=val_acc  # 使用验证集的准确率作为指标，判断是否保存当前模型（通常只保存性能最好的模型）\n",
    "                        )\n",
    "\n",
    "                    # 3. 早停 Early Stop\n",
    "                    if early_stop_callback is not None:\n",
    "                        # 调用早停回调函数，监控验证集准确率是否不再提升\n",
    "                        early_stop_callback(val_acc)  # 传入验证集准确率，用于判断是否满足早停条件\n",
    "                        if early_stop_callback.early_stop:  # 检查是否触发了早停条件\n",
    "                            # 如果触发了早停条件，打印提示信息并结束训练\n",
    "                            print(f\"Early stop at epoch {epoch_id} / global_step {global_step}\")\n",
    "                            return record_dict  # 返回训练记录字典，包含训练过程中的关键指标\n",
    "\n",
    "                # 增加全局步数计数器\n",
    "                # 记录当前训练的步数,控制评估频率和记录训练进度\n",
    "                global_step += 1\n",
    "\n",
    "                # 更新进度条\n",
    "                pbar.update(1)\n",
    "\n",
    "                # 在进度条中显示当前训练的轮次。\n",
    "                # 更新进度条的后缀信息。方便监控训练进度。\n",
    "                pbar.set_postfix({\"epoch\": epoch_id})\n",
    "\n",
    "    # 返回记录的训练和验证性能的字典,包含训练和验证过程中的损失和准确率\n",
    "    return record_dict\n",
    "\n",
    "\n",
    "epoch = 50\n",
    "\n",
    "activation = \"selu\"\n",
    "model = DepthWiseCNN(activation)\n",
    "\n",
    "# 1. 定义损失函数 采用交叉熵损失\n",
    "loss_fct = nn.CrossEntropyLoss()\n",
    "# 2. 定义优化器 采用SGD\n",
    "# Optimizers specified in the torch.optim package\n",
    "optimizer = torch.optim.SGD(model.parameters(), lr=0.001, momentum=0.9)\n",
    "\n",
    "# 1. tensorboard 可视化\n",
    "if not os.path.exists(\"runs\"):\n",
    "    os.mkdir(\"runs\")\n",
    "tensorboard_callback = TensorBoardCallback(f\"runs/DepthWiseCNN-{activation}\")\n",
    "tensorboard_callback.draw_model(model, [1, 1, 28, 28])\n",
    "# 2. save best\n",
    "if not os.path.exists(\"checkpoints\"):\n",
    "    os.makedirs(\"checkpoints\")\n",
    "save_ckpt_callback = SaveCheckpointsCallback(f\"checkpoints/DepthWiseCNN-{activation}\", save_best_only=True)\n",
    "# 3. early stop\n",
    "early_stop_callback = EarlyStopCallback(patience=10)"
   ],
   "id": "137fe8b4d136d05b",
   "outputs": [],
   "execution_count": 22
  },
  {
   "metadata": {
    "ExecuteTime": {
     "end_time": "2025-02-09T09:06:06.709776Z",
     "start_time": "2025-02-09T08:48:46.122419Z"
    }
   },
   "cell_type": "code",
   "source": [
    "model = model.to(device)\n",
    "record = training(\n",
    "    model,\n",
    "    train_loader,\n",
    "    val_loader,\n",
    "    epoch,\n",
    "    loss_fct,\n",
    "    optimizer,\n",
    "    tensorboard_callback=None,\n",
    "    save_ckpt_callback=save_ckpt_callback,\n",
    "    early_stop_callback=early_stop_callback,\n",
    "    eval_step=len(train_loader)\n",
    ")"
   ],
   "id": "5886e2d86e48ffc9",
   "outputs": [
    {
     "data": {
      "text/plain": [
       "  0%|          | 0/85950 [00:00<?, ?it/s]"
      ],
      "application/vnd.jupyter.widget-view+json": {
       "version_major": 2,
       "version_minor": 0,
       "model_id": "11fdc97bbc794e2dbc18caf8a453f838"
      }
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Early stop at epoch 46 / global_step 79074\n"
     ]
    }
   ],
   "execution_count": 23
  },
  {
   "metadata": {
    "ExecuteTime": {
     "end_time": "2025-02-09T09:06:06.853089Z",
     "start_time": "2025-02-09T09:06:06.710781Z"
    }
   },
   "cell_type": "code",
   "source": [
    "#画线要注意的是损失是不一定在零到1之间的\n",
    "def plot_learning_curves(record_dict, sample_step=500):\n",
    "    # build DataFrame\n",
    "    train_df = pd.DataFrame(record_dict[\"train\"]).set_index(\"step\").iloc[::sample_step]\n",
    "    val_df = pd.DataFrame(record_dict[\"val\"]).set_index(\"step\")\n",
    "\n",
    "    # plot\n",
    "    fig_num = len(train_df.columns)\n",
    "    fig, axs = plt.subplots(1, fig_num, figsize=(5 * fig_num, 5))\n",
    "    for idx, item in enumerate(train_df.columns):\n",
    "        axs[idx].plot(train_df.index, train_df[item], label=f\"train_{item}\")\n",
    "        axs[idx].plot(val_df.index, val_df[item], label=f\"val_{item}\")\n",
    "        axs[idx].grid()\n",
    "        axs[idx].legend()\n",
    "        axs[idx].set_xticks(range(0, train_df.index[-1], 5000))\n",
    "        axs[idx].set_xticklabels(map(lambda x: f\"{int(x / 1000)}k\", range(0, train_df.index[-1], 5000)))\n",
    "        axs[idx].set_xlabel(\"step\")\n",
    "\n",
    "    plt.show()\n",
    "\n",
    "\n",
    "plot_learning_curves(record, sample_step=500)  #横坐标是 steps"
   ],
   "id": "587fa25cd39829ce",
   "outputs": [
    {
     "data": {
      "text/plain": [
       "<Figure size 1000x500 with 2 Axes>"
      ],
      "image/png": "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"
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "execution_count": 24
  },
  {
   "metadata": {},
   "cell_type": "markdown",
   "source": "# 评估",
   "id": "814375ad3f315bfc"
  },
  {
   "metadata": {
    "ExecuteTime": {
     "end_time": "2025-02-09T09:06:11.920281Z",
     "start_time": "2025-02-09T09:06:06.853592Z"
    }
   },
   "cell_type": "code",
   "source": [
    "model.load_state_dict(\n",
    "    torch.load(f\"checkpoints/DepthWiseCNN-{activation}/best.ckpt\", weights_only=True, map_location=\"cpu\"))\n",
    "\n",
    "model.eval()\n",
    "loss, acc = evaluating(model, test_loader, loss_fct)\n",
    "print(f\"loss:     {loss:.4f}\\naccuracy: {acc:.4f}\")"
   ],
   "id": "cce41fba31774e43",
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "loss:     2.3026\n",
      "accuracy: 0.1000\n"
     ]
    }
   ],
   "execution_count": 25
  },
  {
   "metadata": {},
   "cell_type": "code",
   "outputs": [],
   "execution_count": null,
   "source": "",
   "id": "d01a607639817de1"
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "Python 3",
   "language": "python",
   "name": "python3"
  },
  "language_info": {
   "codemirror_mode": {
    "name": "ipython",
    "version": 2
   },
   "file_extension": ".py",
   "mimetype": "text/x-python",
   "name": "python",
   "nbconvert_exporter": "python",
   "pygments_lexer": "ipython2",
   "version": "2.7.6"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 5
}
